#include "Utilisateur.h"


char * utilisateurGetNom(Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        return pUtilisateur->Nom;
    }
}


const char * utilisateurGetNom2(const Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        return (const char *)pUtilisateur->Nom;
    }
}


void utilisateurSetNom(Utilisateur *pUtilisateur, const char *Nom)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        strcpy(pUtilisateur->Nom,Nom);
    }
}


char * utilisateurGetPrenom(Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        return pUtilisateur->Prenom;
    }
}


const char * utilisateurGetPrenom2(const Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        return (const char *)pUtilisateur->Prenom;
    }
}


void utilisateurSetPrenom(Utilisateur *pUtilisateur, const char* Prenom)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        strcpy(pUtilisateur->Prenom,Prenom);
    }
}


char * utilisateurGetPassword(Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        return pUtilisateur->Password;
    }
}


const char * utilisateurGetPassword2(const Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        return (const char *)pUtilisateur->Password;
    }
}


void utilisateurSetPassword(Utilisateur *pUtilisateur, const char* Password)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        strcpy(pUtilisateur->Password,Password);
    }
}


ClefPublique* utilisateurGetClefPublique(Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        return pUtilisateur->pClefPublique;
    }
}


const ClefPublique* utilisateurGetClefPublique2(const Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        return (const ClefPublique *)pUtilisateur->pClefPublique;
    }
}


void utilisateurCreerClefPublique(Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        pUtilisateur->pClefPublique=ClefPubliqueGenerer();
    }
}


void utilisateurSetClefPublique(Utilisateur *pUtilisateur, const mpz_t n1, const mpz_t c1)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        mpz_set(pUtilisateur->pClefPublique->n, n1);
        mpz_set(pUtilisateur->pClefPublique->c, c1);
    }
}


ClefPrivee * utilisateurGetClefPrivee(Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        return pUtilisateur->pClefPrivee;
    }

}


const ClefPrivee * utilisateurGetClefPrivee2(const Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        return (const ClefPrivee *)pUtilisateur->pClefPrivee;
    }

}


void utilisateurCreerClefPrivee(Utilisateur *pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        pUtilisateur->pClefPrivee=ClefPriveeGenerer(utilisateurGetClefPublique(pUtilisateur));
    }
}


void utilisateurSetClefPrivee(Utilisateur *pUtilisateur, const mpz_t u1, const mpz_t n1)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        mpz_set(pUtilisateur->pClefPrivee->u, u1);
        mpz_set(pUtilisateur->pClefPrivee->n, n1);
    }
}


int utilisateurComparer(gconstpointer c1, gconstpointer c2)
{
    return strcmp(((Utilisateur *)c1)->Nom, ((Utilisateur *)c2)->Nom);
}


void utilisateurInitialiser(Utilisateur** pUtilisateur)
{
    *pUtilisateur=(Utilisateur *)malloc(sizeof(Utilisateur));
    /* La clef piblique et la clef privee de l'utilisateur seront initialisées par les fonctions ClefPubliqueGenerer() et ClefPriveeGenerer()*/
    //ClefPubliqueInitialiser(&((* pUtilisateur)->pClefPublique));
    //ClefPriveeInitialiser(&((* pUtilisateur)->pClefPrivee));
}

void utilisateurInitialiser2(Utilisateur** pUtilisateur)
{
    /* Pour les fonctions qui n'utilisent pas ClefPubliqueGenerer() et ClefPriveeGenerer() */
    *pUtilisateur=(Utilisateur *)malloc(sizeof(Utilisateur));
    ClefPubliqueInitialiser(&((* pUtilisateur)->pClefPublique));
    ClefPriveeInitialiser(&((* pUtilisateur)->pClefPrivee));
}


void utilisateurLiberer(Utilisateur* pUtilisateur)
{
//    printf("utilisateurLiberer %p\n", pUtilisateur);
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        ClefPubliqueLiberer(utilisateurGetClefPublique(pUtilisateur));
        ClefPriveeLiberer(utilisateurGetClefPrivee(pUtilisateur));
        free(pUtilisateur);
        pUtilisateur=NULL;
    }

}


void utilisateurSaisir(Utilisateur* pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        char nom[20];
        printf("nom: \n");
        scanf("%s", nom);
        utilisateurSetNom(pUtilisateur, nom);
        char prenom[20];
        printf("prenom: \n");
        scanf("%s", prenom);
        utilisateurSetPrenom(pUtilisateur, prenom);
        char password[20];
        printf("password: \n");
        scanf("%s", password);
        utilisateurSetPassword(pUtilisateur, password);
        utilisateurCreerClefPublique(pUtilisateur);
        utilisateurCreerClefPrivee(pUtilisateur);
    }
}


void utilisateurAfficher(const Utilisateur* pUtilisateur)
{
    if (pUtilisateur==NULL)
    {
        printf("L'utilisateur n'a pas été alloué \n");
        exit(-1);
    }
    else
    {
        printf("nom: %s \n", utilisateurGetNom2(pUtilisateur));
        printf("prenom: %s \n", utilisateurGetPrenom2(pUtilisateur));
        printf("password: %s \n", utilisateurGetPassword2(pUtilisateur));
        ClefPubliqueAfficher(utilisateurGetClefPublique2(pUtilisateur));
        ClefPriveeAfficher(utilisateurGetClefPrivee2(pUtilisateur));
    }

}


void testRegressionUtilisateur()
{
    printf("test regression Utilisateur\n");
    Utilisateur *u1;
    utilisateurInitialiser(&u1);
    utilisateurSaisir(u1);
    utilisateurAfficher(u1);
    utilisateurLiberer(u1);
}
